/**
 * 认证管理Composable
 * 提供统一的认证状态管理和缓存机制，减少重复的认证请求
 */
import { ref, computed, watch } from 'vue'
import { authService } from '../services/auth-service'
import { useUserStore } from '../stores/user'
import { useRouter } from 'vue-router'

// 认证状态缓存
interface AuthCache {
  lastCheck: number
  isValid: boolean
  isChecking: boolean
}

// 缓存配置
const CACHE_DURATION = 30000 // 30秒缓存
const authCache = ref<AuthCache>({
  lastCheck: 0,
  isValid: false,
  isChecking: false
})

// 全局认证状态
const isAuthInitialized = ref(false)
const authError = ref<string | null>(null)

// 全局认证状态单例
let authManagerInstance: ReturnType<typeof useAuthManager> | null = null

export function useAuthManager() {
  const userStore = useUserStore()
  const router = useRouter()
  
  // 计算属性：是否已认证
  const isAuthenticated = computed(() => {
    // 如果有用户信息，认为已认证
    if (userStore.userInfo) {
      return true
    }
    
    // 如果缓存有效，返回缓存结果
    if (Date.now() - authCache.value.lastCheck < CACHE_DURATION) {
      return authCache.value.isValid
    }
    
    // 默认返回false
    return false
  })
  
  // 计算属性：是否正在检查认证状态
  const isCheckingAuth = computed(() => authCache.value.isChecking)
  
  // 计算属性：是否有认证错误
  const hasAuthError = computed(() => !!authError.value)
  
  /**
   * 初始化认证状态
   * 在应用启动时调用，确保用户状态正确加载
   */
  async function initializeAuth() {
    // 如果已经初始化，直接返回
    if (isAuthInitialized.value) {
      return
    }
    
    console.log('useAuthManager: 初始化认证状态')
    
    // 初始化用户状态
    userStore.initUserState()
    
    // 如果有token但没有用户信息，尝试验证
    if (userStore.getToken() && !userStore.userInfo) {
      await checkAuthStatus()
    }
    
    isAuthInitialized.value = true
  }
  
  /**
   * 检查认证状态（带缓存）
   * 避免短时间内重复请求，更加谨慎地处理认证状态
   */
  async function checkAuthStatus(forceRefresh = false): Promise<boolean> {
    const now = Date.now()
    
    // 如果正在检查，返回当前缓存状态
    if (authCache.value.isChecking) {
      console.log('useAuthManager: 正在检查认证状态，返回缓存结果')
      return authCache.value.isValid
    }
    
    // 如果缓存有效且不强制刷新，直接返回缓存结果
    if (!forceRefresh && now - authCache.value.lastCheck < CACHE_DURATION) {
      console.log('useAuthManager: 使用缓存结果', authCache.value.isValid)
      return authCache.value.isValid
    }
    
    // 如果没有token，直接返回false
    if (!userStore.getToken()) {
      console.log('useAuthManager: 没有token，设置未认证状态')
      updateAuthCache(false, false)
      return false
    }
    
    // 开始检查认证状态
    updateAuthCache(true, false)
    
    try {
      console.log('useAuthManager: 调用authService.isAuthenticated')
      const isValid = await authService.isAuthenticated()
      
      // 更新缓存
      updateAuthCache(false, isValid)
      
      // 清除错误
      authError.value = null
      
      return isValid
    } catch (error) {
      console.error('useAuthManager: 检查认证状态失败', error)
      
      // 只有在明确是认证错误时才更新缓存为未认证
      const errorMessage = error instanceof Error ? error.message : '认证检查失败'
      if (errorMessage.includes('401') || errorMessage.includes('认证失败') || errorMessage.includes('未授权')) {
        updateAuthCache(false, false)
      } else {
        // 对于其他错误，保持缓存状态，避免因网络问题等导致的误判
        updateAuthCache(false, authCache.value.isValid)
      }
      
      // 设置错误信息
      authError.value = errorMessage
      
      return false
    }
  }
  
  /**
   * 更新认证缓存
   */
  function updateAuthCache(isChecking: boolean, isValid: boolean) {
    authCache.value = {
      lastCheck: Date.now(),
      isValid,
      isChecking
    }
  }
  
  /**
   * 登录
   */
  async function login(username: string, password: string) {
    try {
      authError.value = null
      const response = await authService.login({ username, password })
      
      if (response.code === 0) {
        // 登录成功，更新缓存
        updateAuthCache(false, true)
        return { success: true, data: response.data }
      } else {
        authError.value = response.msg || '登录失败'
        return { success: false, error: response.msg }
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : '登录失败'
      authError.value = errorMessage
      return { success: false, error: errorMessage }
    }
  }
  
  /**
   * 登出
   */
  async function logout() {
    try {
      await authService.logout()
    } catch (error) {
      console.error('登出请求失败', error)
    } finally {
      // 无论请求是否成功，都清除本地状态
      userStore.setUserInfo(null)
      userStore.clearToken()
      updateAuthCache(false, false)
      authError.value = null
      
      // 跳转到登录页
      router.push('/login')
    }
  }
  
  /**
   * 清除认证错误
   */
  function clearAuthError() {
    authError.value = null
  }
  
  /**
   * 强制刷新认证状态
   */
  async function refreshAuthStatus() {
    return checkAuthStatus(true)
  }
  
  // 监听token变化，清除缓存
  watch(
    () => userStore.getToken(),
    (newToken, oldToken) => {
      if (newToken !== oldToken) {
        console.log('useAuthManager: token变化，清除认证缓存')
        authCache.value.lastCheck = 0
      }
    }
  )
  
  return {
    // 状态
    isAuthenticated,
    isCheckingAuth,
    hasAuthError,
    authError,
    
    // 方法
    initializeAuth,
    checkAuthStatus,
    login,
    logout,
    clearAuthError,
    refreshAuthStatus
  }
}

/**
 * 获取全局认证管理器实例
 * 确保整个应用只有一个认证管理器实例
 */
export function getAuthManager() {
  if (!authManagerInstance) {
    authManagerInstance = useAuthManager()
  }
  return authManagerInstance
}